package storage

import (
	"crypto/sha256"
	"encoding/json"
	"fmt"
	"time"

	"github.com/vmihailenco/msgpack/v5"
)

// MetaVersion 元数据格式版本
const (
	MetaVersionV1 = 1 // 初始版本
	MetaVersionV2 = 2 // 分布式版本
)

// BucketConfig stores per-bucket configuration such as versioning, policy and ACL.
type BucketConfig struct {
	Versioning string `json:"versioning"` // "Enabled" | "Suspended" | ""
	Policy     string `json:"policy"`     // raw policy JSON string
	ACL        string `json:"acl"`        // canned ACL, e.g. "private" | "public-read"
	Region     string `json:"region"`     // optional region hint
	Lifecycle  string `json:"lifecycle"`  // lifecycle configuration JSON string
}

// VolumeSegment 表示文件在卷中的一个片段
type VolumeSegment struct {
	SegmentID int   `json:"segment_id"` // 片段ID，用于保证顺序
	VolumeID  int   `json:"volume_id"`  // 卷ID
	Offset    int64 `json:"offset"`     // 在卷中的偏移量
	Size      int64 `json:"size"`       // 这个片段的大小
}

// DeletedObjectRecord 已删除对象的记录，用于垃圾回收和审计
type DeletedObjectRecord struct {
	Bucket       string            `json:"bucket"`        // 桶名
	Key          string            `json:"key"`           // 对象键
	DeletedAt    time.Time         `json:"deleted_at"`    // 删除时间
	Size         int64             `json:"size"`          // 对象大小
	ETag         string            `json:"etag"`          // 对象ETag
	LastModified time.Time         `json:"last_modified"` // 最后修改时间
	ContentType  string            `json:"content_type"`  // 内容类型
	UserMeta     map[string]string `json:"user_meta"`     // 用户元数据
	// Append模式存储相关字段
	VolumeID int             `json:"volume_id,omitempty"` // 存储的卷ID（向后兼容）
	Offset   int64           `json:"offset,omitempty"`    // 在卷中的偏移量（向后兼容）
	Segments []VolumeSegment `json:"segments,omitempty"`  // 文件在多个卷中的片段
}

// ReplicaStatus 副本状态
type ReplicaStatus uint8

const (
	ReplicaStatusActive   ReplicaStatus = 1 // 活跃
	ReplicaStatusSyncing  ReplicaStatus = 2 // 同步中
	ReplicaStatusFailed   ReplicaStatus = 3 // 失败
	ReplicaStatusPending  ReplicaStatus = 4 // 待处理
	ReplicaStatusDeleting ReplicaStatus = 5 // 删除中
)

// String 返回副本状态的字符串表示
func (rs ReplicaStatus) String() string {
	switch rs {
	case ReplicaStatusActive:
		return "active"
	case ReplicaStatusSyncing:
		return "syncing"
	case ReplicaStatusFailed:
		return "failed"
	case ReplicaStatusPending:
		return "pending"
	case ReplicaStatusDeleting:
		return "deleting"
	default:
		return "unknown"
	}
}

// ReplicaInfo 副本信息 - 支持跨卷存储的精练设计
type ReplicaInfo struct {
	NodeID    string        `msgpack:"n" json:"node_id"`    // 节点ID (短字段名减少序列化大小)
	Status    ReplicaStatus `msgpack:"st" json:"status"`    // 状态
	UpdatedAt int64         `msgpack:"u" json:"updated_at"` // 更新时间 (Unix时间戳，减少序列化大小)

	// 存储位置信息 - 支持跨卷存储
	Segments []ReplicaSegment `msgpack:"seg,omitempty" json:"segments,omitempty"` // 副本在多个卷中的片段

	// 向后兼容字段 (当只有一个片段时使用)
	VolumeID int32 `msgpack:"v,omitempty" json:"volume_id,omitempty"` // 单卷ID (向后兼容)
	Offset   int64 `msgpack:"o,omitempty" json:"offset,omitempty"`    // 单卷偏移量 (向后兼容)
	Size     int64 `msgpack:"s,omitempty" json:"size,omitempty"`      // 总大小 (向后兼容)
}

// ReplicaSegment 副本在单个卷中的片段信息
type ReplicaSegment struct {
	VolumeID int32 `msgpack:"v" json:"volume_id"` // 卷ID
	Offset   int64 `msgpack:"o" json:"offset"`    // 在卷中的偏移量
	Size     int64 `msgpack:"s" json:"size"`      // 这个片段的大小
}

// NewReplicaInfo 创建新的副本信息 (单卷版本，向后兼容)
func NewReplicaInfo(nodeID string, volumeID int32, offset, size int64) *ReplicaInfo {
	return &ReplicaInfo{
		NodeID:    nodeID,
		VolumeID:  volumeID,
		Offset:    offset,
		Size:      size,
		Status:    ReplicaStatusActive,
		UpdatedAt: time.Now().Unix(),
		Segments:  make([]ReplicaSegment, 0),
	}
}

// NewReplicaInfoWithSegments 创建支持跨卷的副本信息
func NewReplicaInfoWithSegments(nodeID string, segments []ReplicaSegment) *ReplicaInfo {
	totalSize := int64(0)
	for _, seg := range segments {
		totalSize += seg.Size
	}

	return &ReplicaInfo{
		NodeID:    nodeID,
		Status:    ReplicaStatusActive,
		UpdatedAt: time.Now().Unix(),
		Segments:  segments,
		Size:      totalSize,
	}
}

// IsActive 检查副本是否活跃
func (r *ReplicaInfo) IsActive() bool {
	return r.Status == ReplicaStatusActive
}

// UpdateStatus 更新副本状态
func (r *ReplicaInfo) UpdateStatus(status ReplicaStatus) {
	r.Status = status
	r.UpdatedAt = time.Now().Unix()
}

// GetTotalSize 获取副本总大小
func (r *ReplicaInfo) GetTotalSize() int64 {
	if len(r.Segments) > 0 {
		totalSize := int64(0)
		for _, seg := range r.Segments {
			totalSize += seg.Size
		}
		return totalSize
	}
	return r.Size // 向后兼容
}

// GetSegmentCount 获取片段数量
func (r *ReplicaInfo) GetSegmentCount() int {
	if len(r.Segments) > 0 {
		return len(r.Segments)
	}
	if r.VolumeID > 0 {
		return 1 // 向后兼容，单卷情况
	}
	return 0
}

// IsMultiVolume 检查是否为跨卷副本
func (r *ReplicaInfo) IsMultiVolume() bool {
	return len(r.Segments) > 1
}

// GetVolumeIDs 获取所有卷ID
func (r *ReplicaInfo) GetVolumeIDs() []int32 {
	if len(r.Segments) > 0 {
		volumeIDs := make([]int32, len(r.Segments))
		for i, seg := range r.Segments {
			volumeIDs[i] = seg.VolumeID
		}
		return volumeIDs
	}
	if r.VolumeID > 0 {
		return []int32{r.VolumeID} // 向后兼容
	}
	return []int32{}
}

// AddSegment 添加片段
func (r *ReplicaInfo) AddSegment(volumeID int32, offset, size int64) {
	segment := ReplicaSegment{
		VolumeID: volumeID,
		Offset:   offset,
		Size:     size,
	}
	r.Segments = append(r.Segments, segment)
	r.Size = r.GetTotalSize()
	r.UpdatedAt = time.Now().Unix()
}

// RemoveSegment 移除指定卷的片段
func (r *ReplicaInfo) RemoveSegment(volumeID int32) {
	for i, seg := range r.Segments {
		if seg.VolumeID == volumeID {
			r.Segments = append(r.Segments[:i], r.Segments[i+1:]...)
			r.Size = r.GetTotalSize()
			r.UpdatedAt = time.Now().Unix()
			break
		}
	}
}

// DistributedObjectMeta 分布式对象元数据 - 高性能设计
type DistributedObjectMeta struct {
	// 版本信息
	Version int32 `msgpack:"ver" json:"version"` // 元数据版本

	// 基础信息 (保持与原有格式兼容)
	Size         int64             `msgpack:"sz" json:"size"`                // 对象大小
	ETag         string            `msgpack:"et" json:"etag"`                // ETag
	LastModified int64             `msgpack:"lm" json:"last_modified"`       // 最后修改时间 (Unix时间戳)
	ContentType  string            `msgpack:"ct" json:"content_type"`        // 内容类型
	UserMeta     map[string]string `msgpack:"um,omitempty" json:"user_meta"` // 用户元数据

	// 存储位置信息 (向后兼容)
	VolumeID int32           `msgpack:"vid,omitempty" json:"volume_id,omitempty"` // 主卷ID
	Offset   int64           `msgpack:"off,omitempty" json:"offset,omitempty"`    // 主偏移量
	Segments []VolumeSegment `msgpack:"seg,omitempty" json:"segments,omitempty"`  // 跨卷片段

	// 分布式相关字段
	Replicas  []ReplicaInfo `msgpack:"rep,omitempty" json:"replicas,omitempty"`  // 副本信息
	Checksum  string        `msgpack:"cs,omitempty" json:"checksum,omitempty"`   // 数据校验和
	CreatedAt int64         `msgpack:"ca" json:"created_at"`                     // 创建时间
	UpdatedAt int64         `msgpack:"ua" json:"updated_at"`                     // 更新时间
	DeletedAt int64         `msgpack:"da,omitempty" json:"deleted_at,omitempty"` // 删除时间 (0表示未删除)

	// 扩展字段 (用于未来版本兼容)
	Extensions map[string]interface{} `msgpack:"ext,omitempty" json:"extensions,omitempty"`
}

// NewDistributedObjectMeta 创建新的分布式对象元数据
func NewDistributedObjectMeta() *DistributedObjectMeta {
	now := time.Now().Unix()
	return &DistributedObjectMeta{
		Version:    MetaVersionV2,
		UserMeta:   make(map[string]string),
		Replicas:   make([]ReplicaInfo, 0),
		CreatedAt:  now,
		UpdatedAt:  now,
		Extensions: make(map[string]interface{}),
	}
}

// AddReplica 添加副本
func (d *DistributedObjectMeta) AddReplica(replica *ReplicaInfo) {
	d.Replicas = append(d.Replicas, *replica)
	d.UpdatedAt = time.Now().Unix()
}

// AddReplicaFromSegments 从主元数据的片段创建副本
func (d *DistributedObjectMeta) AddReplicaFromSegments(nodeID string, segments []VolumeSegment) {
	replicaSegments := make([]ReplicaSegment, len(segments))
	for i, seg := range segments {
		replicaSegments[i] = ReplicaSegment{
			VolumeID: int32(seg.VolumeID),
			Offset:   seg.Offset,
			Size:     seg.Size,
		}
	}

	replica := NewReplicaInfoWithSegments(nodeID, replicaSegments)
	d.AddReplica(replica)
}

// RemoveReplica 移除副本
func (d *DistributedObjectMeta) RemoveReplica(nodeID string) {
	for i, replica := range d.Replicas {
		if replica.NodeID == nodeID {
			d.Replicas = append(d.Replicas[:i], d.Replicas[i+1:]...)
			d.UpdatedAt = time.Now().Unix()
			break
		}
	}
}

// GetActiveReplicas 获取活跃副本
func (d *DistributedObjectMeta) GetActiveReplicas() []ReplicaInfo {
	var active []ReplicaInfo
	for _, replica := range d.Replicas {
		if replica.IsActive() {
			active = append(active, replica)
		}
	}
	return active
}

// GetReplicaCount 获取副本数量
func (d *DistributedObjectMeta) GetReplicaCount() int {
	return len(d.GetActiveReplicas())
}

// GetReplicaByNode 获取指定节点的副本
func (d *DistributedObjectMeta) GetReplicaByNode(nodeID string) *ReplicaInfo {
	for _, replica := range d.Replicas {
		if replica.NodeID == nodeID {
			return &replica
		}
	}
	return nil
}

// GetReplicasByVolume 获取包含指定卷的副本
func (d *DistributedObjectMeta) GetReplicasByVolume(volumeID int32) []ReplicaInfo {
	var replicas []ReplicaInfo
	for _, replica := range d.Replicas {
		if replica.IsActive() {
			volumeIDs := replica.GetVolumeIDs()
			for _, vid := range volumeIDs {
				if vid == volumeID {
					replicas = append(replicas, replica)
					break
				}
			}
		}
	}
	return replicas
}

// GetMultiVolumeReplicas 获取跨卷副本
func (d *DistributedObjectMeta) GetMultiVolumeReplicas() []ReplicaInfo {
	var replicas []ReplicaInfo
	for _, replica := range d.Replicas {
		if replica.IsActive() && replica.IsMultiVolume() {
			replicas = append(replicas, replica)
		}
	}
	return replicas
}

// GetSingleVolumeReplicas 获取单卷副本
func (d *DistributedObjectMeta) GetSingleVolumeReplicas() []ReplicaInfo {
	var replicas []ReplicaInfo
	for _, replica := range d.Replicas {
		if replica.IsActive() && !replica.IsMultiVolume() {
			replicas = append(replicas, replica)
		}
	}
	return replicas
}

// IsDeleted 检查是否已删除
func (d *DistributedObjectMeta) IsDeleted() bool {
	return d.DeletedAt > 0
}

// MarkDeleted 标记为已删除
func (d *DistributedObjectMeta) MarkDeleted() {
	d.DeletedAt = time.Now().Unix()
	d.UpdatedAt = d.DeletedAt
}

// UpdateChecksum 更新校验和
func (d *DistributedObjectMeta) UpdateChecksum(data []byte) {
	hash := sha256.Sum256(data)
	d.Checksum = fmt.Sprintf("%x", hash)
	d.UpdatedAt = time.Now().Unix()
}

// ValidateChecksum 验证校验和
func (d *DistributedObjectMeta) ValidateChecksum(data []byte) bool {
	if d.Checksum == "" {
		return true // 没有校验和时认为有效
	}
	hash := sha256.Sum256(data)
	expected := fmt.Sprintf("%x", hash)
	return d.Checksum == expected
}

// Serialize 序列化元数据 (使用MessagePack，比JSON更高效)
func (d *DistributedObjectMeta) Serialize() ([]byte, error) {
	return msgpack.Marshal(d)
}

// Deserialize 反序列化元数据
func (d *DistributedObjectMeta) Deserialize(data []byte) error {
	return msgpack.Unmarshal(data, d)
}

// SerializeJSON 序列化为JSON (用于调试和兼容性)
func (d *DistributedObjectMeta) SerializeJSON() ([]byte, error) {
	return json.Marshal(d)
}

// DeserializeJSON 从JSON反序列化
func (d *DistributedObjectMeta) DeserializeJSON(data []byte) error {
	return json.Unmarshal(data, d)
}

// GetSize 获取序列化后的大小
func (d *DistributedObjectMeta) GetSize() (int, error) {
	data, err := d.Serialize()
	if err != nil {
		return 0, err
	}
	return len(data), nil
}

// Clone 深拷贝元数据
func (d *DistributedObjectMeta) Clone() *DistributedObjectMeta {
	clone := &DistributedObjectMeta{
		Version:      d.Version,
		Size:         d.Size,
		ETag:         d.ETag,
		LastModified: d.LastModified,
		ContentType:  d.ContentType,
		VolumeID:     d.VolumeID,
		Offset:       d.Offset,
		Checksum:     d.Checksum,
		CreatedAt:    d.CreatedAt,
		UpdatedAt:    d.UpdatedAt,
		DeletedAt:    d.DeletedAt,
	}

	// 深拷贝UserMeta
	if d.UserMeta != nil {
		clone.UserMeta = make(map[string]string)
		for k, v := range d.UserMeta {
			clone.UserMeta[k] = v
		}
	}

	// 深拷贝Segments
	if d.Segments != nil {
		clone.Segments = make([]VolumeSegment, len(d.Segments))
		copy(clone.Segments, d.Segments)
	}

	// 深拷贝Replicas
	if d.Replicas != nil {
		clone.Replicas = make([]ReplicaInfo, len(d.Replicas))
		copy(clone.Replicas, d.Replicas)
	}

	// 深拷贝Extensions
	if d.Extensions != nil {
		clone.Extensions = make(map[string]interface{})
		for k, v := range d.Extensions {
			clone.Extensions[k] = v
		}
	}

	return clone
}

// Merge 合并元数据 (用于冲突解决)
func (d *DistributedObjectMeta) Merge(other *DistributedObjectMeta) {
	// 使用更高版本的数据
	if other.Version > d.Version {
		d.Version = other.Version
	}

	// 使用更新的时间戳
	if other.UpdatedAt > d.UpdatedAt {
		d.Size = other.Size
		d.ETag = other.ETag
		d.LastModified = other.LastModified
		d.ContentType = other.ContentType
		d.VolumeID = other.VolumeID
		d.Offset = other.Offset
		d.Segments = other.Segments
		d.Checksum = other.Checksum
		d.UpdatedAt = other.UpdatedAt
		d.DeletedAt = other.DeletedAt

		// 合并UserMeta
		if other.UserMeta != nil {
			if d.UserMeta == nil {
				d.UserMeta = make(map[string]string)
			}
			for k, v := range other.UserMeta {
				d.UserMeta[k] = v
			}
		}

		// 合并Extensions
		if other.Extensions != nil {
			if d.Extensions == nil {
				d.Extensions = make(map[string]interface{})
			}
			for k, v := range other.Extensions {
				d.Extensions[k] = v
			}
		}
	}

	// 合并副本信息 (保留所有活跃副本)
	replicaMap := make(map[string]ReplicaInfo)

	// 先添加当前副本
	for _, replica := range d.Replicas {
		replicaMap[replica.NodeID] = replica
	}

	// 再添加其他副本 (如果更新则覆盖)
	for _, replica := range other.Replicas {
		if existing, exists := replicaMap[replica.NodeID]; !exists || replica.UpdatedAt > existing.UpdatedAt {
			replicaMap[replica.NodeID] = replica
		}
	}

	// 重建副本列表
	d.Replicas = make([]ReplicaInfo, 0, len(replicaMap))
	for _, replica := range replicaMap {
		d.Replicas = append(d.Replicas, replica)
	}
}

// MetaBatch 批量元数据操作
type MetaBatch struct {
	Operations []MetaOperation `msgpack:"ops" json:"operations"`
	Timestamp  int64           `msgpack:"ts" json:"timestamp"`
	NodeID     string          `msgpack:"nid" json:"node_id"`
}

// MetaOperation 元数据操作
type MetaOperation struct {
	Type   string                 `msgpack:"t" json:"type"` // put, delete, update
	Bucket string                 `msgpack:"b" json:"bucket"`
	Key    string                 `msgpack:"k" json:"key"`
	Meta   *DistributedObjectMeta `msgpack:"m,omitempty" json:"meta,omitempty"`
}

// NewMetaBatch 创建新的批量操作
func NewMetaBatch(nodeID string) *MetaBatch {
	return &MetaBatch{
		Operations: make([]MetaOperation, 0),
		Timestamp:  time.Now().Unix(),
		NodeID:     nodeID,
	}
}

// AddOperation 添加操作
func (b *MetaBatch) AddOperation(opType, bucket, key string, meta *DistributedObjectMeta) {
	op := MetaOperation{
		Type:   opType,
		Bucket: bucket,
		Key:    key,
		Meta:   meta,
	}
	b.Operations = append(b.Operations, op)
}

// Serialize 序列化批量操作
func (b *MetaBatch) Serialize() ([]byte, error) {
	return msgpack.Marshal(b)
}

// Deserialize 反序列化批量操作
func (b *MetaBatch) Deserialize(data []byte) error {
	return msgpack.Unmarshal(data, b)
}

// MetaSyncMessage 元数据同步消息
type MetaSyncMessage struct {
	Type      string      `msgpack:"t" json:"type"`       // sync_request, sync_response, heartbeat
	NodeID    string      `msgpack:"nid" json:"node_id"`  // 发送节点ID
	Timestamp int64       `msgpack:"ts" json:"timestamp"` // 时间戳
	Data      interface{} `msgpack:"d" json:"data"`       // 消息数据
}

// NewMetaSyncMessage 创建新的同步消息
func NewMetaSyncMessage(msgType, nodeID string, data interface{}) *MetaSyncMessage {
	return &MetaSyncMessage{
		Type:      msgType,
		NodeID:    nodeID,
		Timestamp: time.Now().Unix(),
		Data:      data,
	}
}

// Serialize 序列化同步消息
func (m *MetaSyncMessage) Serialize() ([]byte, error) {
	return msgpack.Marshal(m)
}

// Deserialize 反序列化同步消息
func (m *MetaSyncMessage) Deserialize(data []byte) error {
	return msgpack.Unmarshal(data, m)
}

// MetaCompressor 元数据压缩器 - 用于减少网络传输
type MetaCompressor struct {
	compressionLevel int
}

// NewMetaCompressor 创建新的压缩器
func NewMetaCompressor(level int) *MetaCompressor {
	return &MetaCompressor{
		compressionLevel: level,
	}
}

// Compress 压缩数据
func (c *MetaCompressor) Compress(data []byte) ([]byte, error) {
	// 这里可以使用gzip或其他压缩算法
	// 为了简化，这里返回原数据
	return data, nil
}

// Decompress 解压数据
func (c *MetaCompressor) Decompress(data []byte) ([]byte, error) {
	// 对应的解压逻辑
	return data, nil
}

// MetaValidator 元数据验证器
type MetaValidator struct{}

// NewMetaValidator 创建新的验证器
func NewMetaValidator() *MetaValidator {
	return &MetaValidator{}
}

// Validate 验证元数据
func (v *MetaValidator) Validate(meta *DistributedObjectMeta) error {
	// 基础字段验证
	if meta.Version <= 0 {
		return fmt.Errorf("invalid version: %d", meta.Version)
	}

	if meta.Size < 0 {
		return fmt.Errorf("invalid size: %d", meta.Size)
	}

	if meta.ETag == "" {
		return fmt.Errorf("etag is required")
	}

	if meta.LastModified <= 0 {
		return fmt.Errorf("invalid last_modified: %d", meta.LastModified)
	}

	if meta.CreatedAt <= 0 {
		return fmt.Errorf("invalid created_at: %d", meta.CreatedAt)
	}

	if meta.UpdatedAt <= 0 {
		return fmt.Errorf("invalid updated_at: %d", meta.UpdatedAt)
	}

	// 时间逻辑验证
	if meta.UpdatedAt < meta.CreatedAt {
		return fmt.Errorf("updated_at cannot be before created_at")
	}

	if meta.DeletedAt > 0 && meta.DeletedAt < meta.CreatedAt {
		return fmt.Errorf("deleted_at cannot be before created_at")
	}

	// 副本验证
	for i, replica := range meta.Replicas {
		if replica.NodeID == "" {
			return fmt.Errorf("replica %d: node_id is required", i)
		}

		if replica.VolumeID < 0 {
			return fmt.Errorf("replica %d: invalid volume_id: %d", i, replica.VolumeID)
		}

		if replica.Offset < 0 {
			return fmt.Errorf("replica %d: invalid offset: %d", i, replica.Offset)
		}

		if replica.Size < 0 {
			return fmt.Errorf("replica %d: invalid size: %d", i, replica.Size)
		}
	}

	return nil
}

// MetaMetrics 元数据性能指标
type MetaMetrics struct {
	SerializeTime    time.Duration `json:"serialize_time"`
	DeserializeTime  time.Duration `json:"deserialize_time"`
	CompressTime     time.Duration `json:"compress_time"`
	DecompressTime   time.Duration `json:"decompress_time"`
	OriginalSize     int           `json:"original_size"`
	CompressedSize   int           `json:"compressed_size"`
	CompressionRatio float64       `json:"compression_ratio"`
}

// CalculateCompressionRatio 计算压缩比
func (m *MetaMetrics) CalculateCompressionRatio() {
	if m.OriginalSize > 0 {
		m.CompressionRatio = float64(m.CompressedSize) / float64(m.OriginalSize)
	}
}

// BenchmarkMeta 性能基准测试
func BenchmarkMeta(meta *DistributedObjectMeta) (*MetaMetrics, error) {
	metrics := &MetaMetrics{}

	// 序列化测试
	start := time.Now()
	data, err := meta.Serialize()
	if err != nil {
		return nil, err
	}
	metrics.SerializeTime = time.Since(start)
	metrics.OriginalSize = len(data)

	// 反序列化测试
	start = time.Now()
	var newMeta DistributedObjectMeta
	err = newMeta.Deserialize(data)
	if err != nil {
		return nil, err
	}
	metrics.DeserializeTime = time.Since(start)

	// 压缩测试
	compressor := NewMetaCompressor(6)
	start = time.Now()
	compressed, err := compressor.Compress(data)
	if err != nil {
		return nil, err
	}
	metrics.CompressTime = time.Since(start)
	metrics.CompressedSize = len(compressed)

	// 解压测试
	start = time.Now()
	_, err = compressor.Decompress(compressed)
	if err != nil {
		return nil, err
	}
	metrics.DecompressTime = time.Since(start)

	metrics.CalculateCompressionRatio()

	return metrics, nil
}
